```html
<!DOCTYPE html>
<html lang="zh-CN">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>数据去重方法全解析 | 技术小馆</title>
    <link rel="stylesheet" href="https://cdn.staticfile.org/font-awesome/6.4.0/css/all.min.css">
    <link rel="stylesheet" href="https://cdn.staticfile.org/tailwindcss/2.2.19/tailwind.min.css">
    <link href="https://fonts.googleapis.com/css2?family=Noto+Serif+SC:wght@400;500;600;700&family=Noto+Sans+SC:wght@300;400;500;700&display=swap" rel="stylesheet">
    <script src="https://cdn.jsdelivr.net/npm/mermaid@latest/dist/mermaid.min.js"></script>
    <style>
        body {
            font-family: 'Noto Sans SC', Tahoma, Arial, Roboto, "Droid Sans", "Helvetica Neue", "Droid Sans Fallback", "Heiti SC", "Hiragino Sans GB", Simsun, sans-serif;
            color: #333;
            line-height: 1.8;
        }
        h1, h2, h3, h4 {
            font-family: 'Noto Serif SC', serif;
            font-weight: 700;
        }
        .hero-gradient {
            background: linear-gradient(135deg, #6e8efb 0%, #4a6cf7 100%);
        }
        .card-hover:hover {
            transform: translateY(-5px);
            box-shadow: 0 10px 25px rgba(0,0,0,0.1);
        }
        .code-block {
            background-color: #f8f9fa;
            border-left: 4px solid #4a6cf7;
        }
        .section-divider {
            border-top: 1px solid rgba(0,0,0,0.1);
            position: relative;
        }
        .section-divider::after {
            content: '';
            position: absolute;
            top: -5px;
            left: 50%;
            transform: translateX(-50%);
            width: 100px;
            height: 3px;
            background: #4a6cf7;
            border-radius: 3px;
        }
        .mermaid {
            background-color: white;
            padding: 20px;
            border-radius: 8px;
            box-shadow: 0 4px 12px rgba(0,0,0,0.05);
        }
    </style>
</head>
<body class="bg-gray-50">
    <!-- Hero Section -->
    <section class="hero-gradient text-white py-20 px-4 md:px-0">
        <div class="container mx-auto max-w-5xl text-center">
            <h1 class="text-4xl md:text-5xl font-bold mb-6 animate-fade-in">
                数据去重方法全解析
            </h1>
            <p class="text-xl md:text-2xl mb-8 max-w-3xl mx-auto opacity-90">
                从数据结构到分布式处理，掌握高效去重技术，提升数据质量
            </p>
            <div class="flex justify-center space-x-4">
                <a href="#methods" class="bg-white text-blue-600 px-6 py-3 rounded-full font-semibold hover:bg-gray-100 transition-all duration-300">
                    <i class="fas fa-book-open mr-2"></i>学习技术
                </a>
                <a href="#visualization" class="border-2 border-white text-white px-6 py-3 rounded-full font-semibold hover:bg-white hover:text-blue-600 transition-all duration-300">
                    <i class="fas fa-project-diagram mr-2"></i>可视化
                </a>
            </div>
        </div>
    </section>

    <!-- Introduction Section -->
    <section class="py-16 px-4 md:px-0 bg-white">
        <div class="container mx-auto max-w-5xl">
            <div class="flex flex-col md:flex-row items-center">
                <div class="md:w-1/2 mb-8 md:mb-0 md:pr-8">
                    <img src="https://cdn.nlark.com/yuque/0/2024/png/21449790/1717385809463-f2a36584-ac39-40b6-b142-d804b632b21b.png" 
                         alt="数据去重概念图" 
                         class="rounded-lg shadow-xl w-full h-auto">
                </div>
                <div class="md:w-1/2">
                    <h2 class="text-3xl font-bold mb-6 text-gray-800">为什么数据去重如此重要？</h2>
                    <p class="text-gray-700 mb-4">
                        数据已经成为其核心资产，然而，随着数据量的爆炸性增长，数据重复的问题也变得日益严重。重复数据不仅会占用大量存储空间，还会导致数据分析结果的不准确，进而影响决策的质量。
                    </p>
                    <p class="text-gray-700 mb-6">
                        数据去重是一项基础而又关键的任务，它不仅在数据清洗过程中起着重要作用，还在数据整合、数据迁移以及大数据处理等多个环节中扮演着不可或缺的角色。去重的目标是识别并删除重复的记录，从而确保数据的唯一性和一致性。
                    </p>
                    <div class="bg-blue-50 border-l-4 border-blue-500 p-4 rounded">
                        <p class="text-blue-800 font-medium">
                            <i class="fas fa-lightbulb text-blue-500 mr-2"></i>
                            掌握高效的数据去重方法可以显著提升数据处理效率，降低存储成本，并确保分析结果的准确性。
                        </p>
                    </div>
                </div>
            </div>
        </div>
    </section>

    <!-- Common Problems Section -->
    <section class="py-16 px-4 md:px-0 bg-gray-50">
        <div class="container mx-auto max-w-5xl">
            <div class="text-center mb-12">
                <h2 class="text-3xl font-bold text-gray-800 mb-4">常见的数据重复问题</h2>
                <p class="text-gray-600 max-w-2xl mx-auto">
                    通过理解和识别这些常见的数据重复问题，能够有针对性地选择和应用合适的数据去重方法，提高数据质量，确保分析结果的准确性和可靠性。
                </p>
            </div>
            
            <div class="grid md:grid-cols-2 gap-8">
                <!-- Problem 1 -->
                <div class="bg-white p-6 rounded-xl shadow-md card-hover transition-all duration-300">
                    <div class="flex items-center mb-4">
                        <div class="bg-red-100 p-3 rounded-full mr-4">
                            <i class="fas fa-clone text-red-500 text-xl"></i>
                        </div>
                        <h3 class="text-xl font-bold text-gray-800">重复记录</h3>
                    </div>
                    <p class="text-gray-700">
                        数据集中存在两条或多条内容完全相同的记录。这会浪费存储空间，影响数据查询和分析的准确性，并导致统计结果重复计算。常见于数据录入错误或缺乏去重机制。
                    </p>
                </div>
                
                <!-- Problem 2 -->
                <div class="bg-white p-6 rounded-xl shadow-md card-hover transition-all duration-300">
                    <div class="flex items-center mb-4">
                        <div class="bg-blue-100 p-3 rounded-full mr-4">
                            <i class="fas fa-database text-blue-500 text-xl"></i>
                        </div>
                        <h3 class="text-xl font-bold text-gray-800">数据冗余</h3>
                    </div>
                    <p class="text-gray-700">
                        不同的数据集中包含重复的记录。它增加了数据管理和维护的复杂度，并容易引起数据一致性问题，导致数据冲突。常见于数据集成或数据迁移过程中。
                    </p>
                </div>
                
                <!-- Problem 3 -->
                <div class="bg-white p-6 rounded-xl shadow-md card-hover transition-all duration-300">
                    <div class="flex items-center mb-4">
                        <div class="bg-purple-100 p-3 rounded-full mr-4">
                            <i class="fas fa-code-branch text-purple-500 text-xl"></i>
                        </div>
                        <h3 class="text-xl font-bold text-gray-800">部分重复</h3>
                    </div>
                    <p class="text-gray-700">
                        记录中某些字段内容相同，但其他字段不同。这种情况增加了数据清洗的复杂度，影响数据质量和准确性。常由于数据录入错误或不同来源数据不一致造成。
                    </p>
                </div>
                
                <!-- Problem 4 -->
                <div class="bg-white p-6 rounded-xl shadow-md card-hover transition-all duration-300">
                    <div class="flex items-center mb-4">
                        <div class="bg-yellow-100 p-3 rounded-full mr-4">
                            <i class="fas fa-ghost text-yellow-500 text-xl"></i>
                        </div>
                        <h3 class="text-xl font-bold text-gray-800">虚假重复</h3>
                    </div>
                    <p class="text-gray-700">
                        由于数据标准化不足或格式不一致造成的看似重复但实际不同的记录。它会影响去重算法的准确性，增加数据处理的复杂度。常见于姓名大小写或格式不一致等情况。
                    </p>
                </div>
            </div>
            
            <div class="mt-12 text-center">
                <img src="https://cdn.nlark.com/yuque/0/2024/png/21449790/1717386701662-1ed7afd2-6cbc-4682-ac61-1e31ebe76776.png" 
                     alt="数据重复问题示意图" 
                     class="rounded-lg shadow-lg mx-auto w-full max-w-2xl">
            </div>
        </div>
    </section>

    <!-- Data Structure Methods Section -->
    <section id="methods" class="py-16 px-4 md:px-0 bg-white">
        <div class="container mx-auto max-w-5xl">
            <div class="text-center mb-12">
                <h2 class="text-3xl font-bold text-gray-800 mb-4">基于数据结构去重</h2>
                <p class="text-gray-600 max-w-2xl mx-auto">
                    利用不同的数据结构特性可以有效解决数据去重问题，选择合适的数据结构能显著提升去重效率。
                </p>
            </div>
            
            <div class="flex flex-col md:flex-row mb-12">
                <div class="md:w-1/2 mb-8 md:mb-0 md:pr-8">
                    <img src="https://cdn.nlark.com/yuque/0/2024/png/21449790/1717386641427-f2c1044b-38dd-4cdf-b41c-3ed6a76fe719.png" 
                         alt="数据结构去重示意图" 
                         class="rounded-lg shadow-xl w-full h-auto">
                </div>
                <div class="md:w-1/2">
                    <div class="bg-blue-50 p-6 rounded-lg mb-6">
                        <h3 class="text-xl font-bold text-blue-800 mb-3">关键数据结构选择</h3>
                        <ul class="space-y-3">
                            <li class="flex items-start">
                                <i class="fas fa-check-circle text-blue-500 mr-2 mt-1"></i>
                                <span><strong>集合(Set):</strong> 自动去重，操作高效</span>
                            </li>
                            <li class="flex items-start">
                                <i class="fas fa-check-circle text-blue-500 mr-2 mt-1"></i>
                                <span><strong>映射(Map):</strong> 键唯一性保证去重</span>
                            </li>
                            <li class="flex items-start">
                                <i class="fas fa-check-circle text-blue-500 mr-2 mt-1"></i>
                                <span><strong>位图:</strong> 空间高效，适合大规模整数去重</span>
                            </li>
                        </ul>
                    </div>
                </div>
            </div>
            
            <div class="grid md:grid-cols-2 gap-8">
                <!-- Method 1 -->
                <div class="bg-white border border-gray-100 p-6 rounded-xl shadow-sm card-hover transition-all duration-300">
                    <div class="flex items-center mb-4">
                        <div class="bg-green-100 p-3 rounded-full mr-4">
                            <i class="fas fa-boxes text-green-500 text-xl"></i>
                        </div>
                        <h3 class="text-xl font-bold text-gray-800">使用集合 (Set)</h3>
                    </div>
                    <p class="text-gray-700 mb-4">
                        集合是一种不允许包含重复元素的数据结构。常见的实现包括 HashSet、TreeSet 和 LinkedHashSet。
                    </p>
                    <ul class="text-gray-600 text-sm space-y-2 mb-4">
                        <li class="flex items-start">
                            <i class="fas fa-caret-right text-green-500 mr-2 mt-1"></i>
                            <span>HashSet 基于哈希表，插入、删除和查找操作的时间复杂度为 O(1)</span>
                        </li>
                        <li class="flex items-start">
                            <i class="fas fa-caret-right text-green-500 mr-2 mt-1"></i>
                            <span>TreeSet 基于红黑树，保证元素有序，操作的时间复杂度为 O(log n)</span>
                        </li>
                        <li class="flex items-start">
                            <i class="fas fa-caret-right text-green-500 mr-2 mt-1"></i>
                            <span>LinkedHashSet 保留插入顺序，适用于需要顺序去重的场景</span>
                        </li>
                    </ul>
                </div>
                
                <!-- Method 2 -->
                <div class="bg-white border border-gray-100 p-6 rounded-xl shadow-sm card-hover transition-all duration-300">
                    <div class="flex items-center mb-4">
                        <div class="bg-orange-100 p-3 rounded-full mr-4">
                            <i class="fas fa-map-marked-alt text-orange-500 text-xl"></i>
                        </div>
                        <h3 class="text-xl font-bold text-gray-800">使用 Map</h3>
                    </div>
                    <p class="text-gray-700 mb-4">
                        使用 Map（如 HashMap 和 TreeMap）可以实现高效的去重。通过将数据的特定字段作为键，利用键的唯一性特性来去重。
                    </p>
                    <ul class="text-gray-600 text-sm space-y-2 mb-4">
                        <li class="flex items-start">
                            <i class="fas fa-caret-right text-orange-500 mr-2 mt-1"></i>
                            <span>HashMap 基于哈希表，操作的时间复杂度为 O(1)，适用于无序数据</span>
                        </li>
                        <li class="flex items-start">
                            <i class="fas fa-caret-right text-orange-500 mr-2 mt-1"></i>
                            <span>TreeMap 基于红黑树，操作的时间复杂度为 O(log n)，适用于需要按键排序的场景</span>
                        </li>
                    </ul>
                </div>
                
                <!-- Method 3 -->
                <div class="bg-white border border-gray-100 p-6 rounded-xl shadow-sm card-hover transition-all duration-300">
                    <div class="flex items-center mb-4">
                        <div class="bg-purple-100 p-3 rounded-full mr-4">
                            <i class="fas fa-stream text-purple-500 text-xl"></i>
                        </div>
                        <h3 class="text-xl font-bold text-gray-800">使用 Stream API</h3>
                    </div>
                    <p class="text-gray-700 mb-4">
                        Java 8 引入的 Stream API 提供了便捷的去重方法。通过 distinct() 方法可以轻松去重，内部使用 HashSet 实现。
                    </p>
                    <div class="code-block p-4 rounded mb-4">
                        <code class="text-sm text-gray-800">
                            // 使用distinct()去重<br>
                            List&lt;String&gt; distinctList = list.stream()<br>
                            &nbsp;&nbsp;.distinct()<br>
                            &nbsp;&nbsp;.collect(Collectors.toList());<br><br>
                            
                            // 使用toSet()去重<br>
                            Set&lt;String&gt; distinctSet = list.stream()<br>
                            &nbsp;&nbsp;.collect(Collectors.toSet());
                        </code>
                    </div>
                </div>
                
                <!-- Method 4 -->
                <div class="bg-white border border-gray-100 p-6 rounded-xl shadow-sm card-hover transition-all duration-300">
                    <div class="flex items-center mb-4">
                        <div class="bg-blue-100 p-3 rounded-full mr-4">
                            <i class="fas fa-sort-amount-up text-blue-500 text-xl"></i>
                        </div>
                        <h3 class="text-xl font-bold text-gray-800">基于排序的去重</h3>
                    </div>
                    <p class="text-gray-700 mb-4">
                        对数据进行排序后，再通过遍历数据比较相邻元素来去重。此方法的时间复杂度主要由排序决定，为 O(n log n)。
                    </p>
                    <ul class="text-gray-600 text-sm space-y-2 mb-4">
                        <li class="flex items-start">
                            <i class="fas fa-caret-right text-blue-500 mr-2 mt-1"></i>
                            <span>在数据较大且内存有限的情况下，可以结合外部排序算法</span>
                        </li>
                        <li class="flex items-start">
                            <i class="fas fa-caret-right text-blue-500 mr-2 mt-1"></i>
                            <span>排序去重适用于数据量大且需要保持有序的场景，但需要额外的排序开销</span>
                        </li>
                    </ul>
                </div>
            </div>
        </div>
    </section>

    <!-- Database Methods Section -->
    <section class="py-16 px-4 md:px-0 bg-gray-50">
        <div class="container mx-auto max-w-5xl">
            <div class="text-center mb-12">
                <h2 class="text-3xl font-bold text-gray-800 mb-4">基于数据库去重</h2>
                <p class="text-gray-600 max-w-2xl mx-auto">
                    数据库系统提供了多种内置的去重方法，可以高效处理存储在数据库中的重复数据。
                </p>
            </div>
            
            <div class="grid md:grid-cols-2 gap-8">
                <!-- Method 1 -->
                <div class="bg-white p-6 rounded-xl shadow-md card-hover transition-all duration-300">
                    <div class="flex items-center mb-4">
                        <div class="bg-red-100 p-3 rounded-full mr-4">
                            <i class="fas fa-key text-red-500 text-xl"></i>
                        </div>
                        <h3 class="text-xl font-bold text-gray-800">使用 DISTINCT 关键字</h3>
                    </div>
                    <p class="text-gray-700 mb-4">
                        DISTINCT 关键字用于从结果集中检索唯一的值，去除重复的行。它适用于简单的去重需求，这种方法对于简单的数据集合去重是直接有效的，但不支持复杂的去重逻辑。
                    </p>
                    <div class="code-block p-4 rounded">
                        <code class="text-sm text-gray-800">
                            SELECT DISTINCT column1, column2, ...
                            FROM table_name;
                        </code>
                    </div>
                </div>
                
                <!-- Method 2 -->
                <div class="bg-white p-6 rounded-xl shadow-md card-hover transition-all duration-300">
                    <div class="flex items-center mb-4">
                        <div class="bg-green-100 p-3 rounded-full mr-4">
                            <i class="fas fa-layer-group text-green-500 text-xl"></i>
                        </div>
                        <h3 class="text-xl font-bold text-gray-800">使用 GROUP BY 和聚合函数</h3>
                    </div>
                    <p class="text-gray-700 mb-4">
                        GROUP BY 和聚合函数结合使用可以对数据进行分组，并使用聚合函数来去重。这种方法可以根据指定列的组合去重，并支持更复杂的聚合操作。
                    </p>
                    <div class="code-block p-4 rounded">
                        <code class="text-sm text-gray-800">
                            SELECT column1, column2, ...
                            FROM table_name
                            GROUP BY column1, column2, ...;
                        </code>
                    </div>
                </div>
                
                <!-- Method 3 -->
                <div class="bg-white p-6 rounded-xl shadow-md card-hover transition-all duration-300">
                    <div class="flex items-center mb-4">
                        <div class="bg-blue-100 p-3 rounded-full mr-4">
                            <i class="fas fa-window-maximize text-blue-500 text-xl"></i>
                        </div>
                        <h3 class="text-xl font-bold text-gray-800">使用窗口函数</h3>
                    </div>
                    <p class="text-gray-700 mb-4">
                        窗口函数是一种高级 SQL 技术，可以对结果集中的行进行排序、排名和分组。结合窗口函数可以实现复杂的去重逻辑。
                    </p>
                    <div class="code-block p-4 rounded">
                        <code class="text-sm text-gray-800">
                            SELECT *
                            FROM (
                                SELECT *, ROW_NUMBER() OVER(PARTITION BY column1, column2 ORDER BY column3) AS row_num
                                FROM table_name
                            ) AS subquery
                            WHERE row_num = 1;
                        </code>
                    </div>
                </div>
                
                <!-- Method 4 -->
                <div class="bg-white p-6 rounded-xl shadow-md card-hover transition-all duration-300">
                    <div class="flex items-center mb-4">
                        <div class="bg-purple-100 p-3 rounded-full mr-4">
                            <i class="fas fa-merge text-purple-500 text-xl"></i>
                        </div>
                        <h3 class="text-xl font-bold text-gray-800">使用 MERGE INTO</h3>
                    </div>
                    <p class="text-gray-700 mb-4">
                        MERGE INTO 是一种强大的 SQL 操作，可以根据一些条件来合并和更新数据，同时去除重复的行。
                    </p>
                    <div class="code-block p-4 rounded">
                        <code class="text-sm text-gray-800">
                            MERGE INTO target_table t
                            USING (
                                SELECT DISTINCT column1, column2, ...
                                FROM source_table
                            ) s
                            ON (t.column1 = s.column1 AND t.column2 = s.column2 AND ...)
                            WHEN NOT MATCHED THEN INSERT (column1, column2, ...)
                            VALUES (s.column1, s.column2, ...);
                        </code>
                    </div>
                </div>
            </div>
        </div>
    </section>

    <!-- Algorithm Methods Section -->
    <section class="py-16 px-4 md:px-0 bg-white">
        <div class="container mx-auto max-w-5xl">
            <div class="text-center mb-12">
                <h2 class="text-3xl font-bold text-gray-800 mb-4">基于算法去重</h2>
                <p class="text-gray-600 max-w-2xl mx-auto">
                    各种去重算法适用于不同的场景，选择合适的算法可以显著提升去重效率。
                </p>
            </div>
            
            <div class="grid md:grid-cols-2 gap-8">
                <!-- Algorithm 1 -->
                <div class="bg-white border border-gray-100 p-6 rounded-xl shadow-sm card-hover transition-all duration-300">
                    <div class="flex items-center mb-4">
                        <div class="bg-amber-100 p-3 rounded-full mr-4">
                            <i class="fas fa-hashtag text-amber-500 text-xl"></i>
                        </div>
                        <h3 class="text-xl font-bold text-gray-800">哈希表法</h3>
                    </div>
                    <ul class="text-gray-600 text-sm space-y-2 mb-4">
                        <li class="flex items-start">
                            <i class="fas fa-caret-right text-amber-500 mr-2 mt-1"></i>
                            <span><strong>算法原理：</strong>使用哈希表存储已经出现过的元素，当新元素与哈希表中的元素发生冲突时，判定为重复元素</span>
                        </li>
                        <li class="flex items-start">
                            <i class="fas fa-caret-right text-amber-500 mr-2 mt-1"></i>
                            <span><strong>适用场景：</strong>适用于内存充足且数据量较小的情况，时间复杂度为 O(n)，空间复杂度为 O(n)</span>
                        </li>
                    </ul>
                </div>
                
                <!-- Algorithm 2 -->
                <div class="bg-white border border-gray-100 p-6 rounded-xl shadow-sm card-hover transition-all duration-300">
                    <div class="flex items-center mb-4">
                        <div class="bg-emerald-100 p-3 rounded-full mr-4">
                            <i class="fas fa-sort-amount-down text-emerald-500 text-xl"></i>
                        </div>
                        <h3 class="text-xl font-bold text-gray-800">排序法</h3>
                    </div>
                    <ul class="text-gray-600 text-sm space-y-2 mb-4">
                        <li class="flex items-start">
                            <i class="fas fa-caret-right text-emerald-500 mr-2 mt-1"></i>
                            <span><strong>算法原理：</strong>将数据集排序，然后遍历数据集，对比相邻元素，删除重复元素</span>
                        </li>
                        <li class="flex items-start">
                            <i class="fas fa-caret-right text-emerald-500 mr-2 mt-1"></i>
                            <span><strong>适用场景：</strong>适用于数据量较大但内存空间有限的情况，时间复杂度为 O(n log n)，空间复杂度取决于排序算法的实现</span>
                        </li>
                    </ul>
                </div>
                
                <!-- Algorithm 3 -->
                <div class="bg-white border border-gray-100 p-6 rounded-xl shadow-sm card-hover transition-all duration-300">
                    <div class="flex items-center mb-4">
                        <div class="bg-blue-100 p-3 rounded-full mr-4">
                            <i class="fas fa-exchange-alt text-blue-500 text-xl"></i>
                        </div>
                        <h3 class="text-xl font-bold text-gray-800">双指针法</h3>
                    </div>
                    <ul class="text-gray-600 text-sm space-y-2 mb-4">
                        <li class="flex items-start">
                            <i class="fas fa-caret-right text-blue-500 mr-2 mt-1"></i>
                            <span><strong>算法原理：</strong>使用两个指针遍历数组，一个指针用于读取元素，另一个指针用于存储非重复元素</span>
                        </li>
                        <li class="flex items-start">
                            <i class="fas fa-caret-right text-blue-500 mr-2 mt-1"></i>
                            <span><strong>适用场景：</strong>适用于有序数组去重，时间复杂度为 O(n)，空间复杂度为 O(1)</span>
                        </li>
                    </ul>
                </div>
                
                <!-- Algorithm 4 -->
                <div class="bg-white border border-gray-100 p-6 rounded-xl shadow-sm card-hover transition-all duration-300">
                    <div class="flex items-center mb-4">
                        <div class="bg-purple-100 p-3 rounded-full mr-4">
                            <i class="fas fa-filter text-purple-500 text-xl"></i>
                        </div>
                        <h3 class="text-xl font-bold text-gray-800">布隆过滤器</h3>
                    </div>
                    <ul class="text-gray-600 text-sm space-y-2 mb-4">
                        <li class="flex items-start">
                            <i class="fas fa-caret-right text-purple-500 mr-2 mt-1"></i>
                            <span><strong>算法原理：</strong>布隆过滤器是一种空间效率高、可能出错的概率低的数据结构，用于判断一个元素是否在集合中</span>
                        </li>
                        <li class="flex items-start">
                            <i class="fas fa-caret-right text-purple-500 mr-2 mt-1"></i>
                            <span><strong>适用场景：</strong>适用于需要快速判断元素是否可能存在，但不适用于确切的去重操作</span>
                        </li>
                    </ul>
                </div>
            </div>
        </div>
    </section>

    <!-- Tools Section -->
    <section class="py-16 px-4 md:px-0 bg-gray-50">
        <div class="container mx-auto max-w-5xl">
            <div class="text-center mb-12">
                <h2 class="text-3xl font-bold text-gray-800 mb-4">基于外部工具去重</h2>
                <p class="text-gray-600 max-w-2xl mx-auto">
                    各种成熟的工具和框架提供了高效的去重功能，可以简化开发工作。
                </p>
            </div>
            
            <div class="grid md:grid-cols-2 gap-8">
                <!-- Tool 1 -->
                <div class="bg-white p-6 rounded-xl shadow-md card-hover transition-all duration-300">
                    <div class="flex items-center mb-4">
                        <div class="bg-red-100 p-3 rounded-full mr-4">
                            <img src="https://commons.apache.org/proper/commons-collections/images/commons-logo.png" class="h-8 w-8" alt="Apache Commons">
                        </div>
                        <h3 class="text-xl font-bold text-gray-800">Apache Commons Collections</h3>
                    </div>
                    <p class="text-gray-700 mb-4">
                        Apache Commons Collections 是一个扩展了 Java 标准集合框架的库，提供了更多集合工具和功能。
                    </p>
                    <div class="code-block p-4 rounded mb-4">
                        <code class="text-sm text-gray-800">
                            Collection&lt;String&gt; uniqueCollection = <br>
                            &nbsp;&nbsp;CollectionUtils.removeAll(data, duplicates);
                        </code>
                    </div>
                    <p class="text-gray-600 text-sm">
                        <i class="fas fa-check-circle text-green-500 mr-1"></i>
                        提供丰富的集合操作工具；适用于复杂集合操作需求，简化代码实现
                    </p>
                </div>
                
                <!-- Tool 2 -->
                <div class="bg-white p-6 rounded-xl shadow-md card-hover transition-all duration-300">
                    <div class="flex items-center mb-4">
                        <div class="bg-blue-100 p-3 rounded-full mr-4">
                            <img src="https://www.gstatic.com/devrel-devsite/prod/v45f61267e228d69e2f93c2c8968df3d7f9558fad0d8e70e8b09e2f03d3b4dfa/developers/images/touchicon-180.png" class="h-8 w-8" alt="Google Guava">
                        </div>
                        <h3 class="text-xl font-bold text-gray-800">Google Guava</h3>
                    </div>
                    <p class="text-gray-700 mb-4">
                        Google Guava 是一个广泛使用的 Java 库，提供了强大的集合工具类。
                    </p>
                    <div class="code-block p-4 rounded mb-4">
                        <code class="text-sm text-gray-800">
                            Set&lt;String&gt; uniqueSet = Sets.newHashSet(data);
                        </code>
                    </div>
                    <p class="text-gray-600 text-sm">
                        <i class="fas fa-check-circle text-green-500 mr-1"></i>
                        丰富的集合操作工具；高效简洁，适用于各种集合操作需求
                    </p>
                </div>
                
                <!-- Tool 3 -->
                <div class="bg-white p-6 rounded-xl shadow-md card-hover transition-all duration-300">
                    <div class="flex items-center mb-4">
                        <div class="bg-orange-100 p-3 rounded-full mr-4">
                            <img src="https://spark.apache.org/images/spark-logo-trademark.png" class="h-8 w-8" alt="Apache Spark">
                        </div>
                        <h3 class="text-xl font-bold text-gray-800">Apache Spark</h3>
                    </div>
                    <p class="text-gray-700 mb-4">
                        Apache Spark 是一个分布式数据处理框架，支持大规模数据集的去重操作。
                    </p>
                    <div class="code-block p-4 rounded mb-4">
                        <code class="text-sm text-gray-800">
                            JavaRDD&lt;String&gt; rdd = sparkContext.parallelize(data);<br>
                            JavaRDD&lt;String&gt; uniqueRdd = rdd.distinct();
                        </code>
                    </div>
                    <p class="text-gray-600 text-sm">
                        <i class="fas fa-check-circle text-green-500 mr-1"></i>
                        支持大规模数据处理；高效分布式计算，适用于需要大数据去重的场景
                    </p>
                </div>
                
                <!-- Tool 4 -->
                <div class="bg-white p-6 rounded-xl shadow-md card-hover transition-all duration-300">
                    <div class="flex items-center mb-4">
                        <div class="bg-purple-100 p-3 rounded-full mr-4">
                            <img src="https://flink.apache.org/img/flink-header-logo.svg" class="h-8 w-8" alt="Apache Flink">
                        </div>
                        <h3 class="text-xl font-bold text-gray-800">Apache Flink</h3>
                    </div>
                    <p class="text-gray-700 mb-4">
                        Apache Flink 是一个流处理框架，支持实时数据流的去重操作。
                    </p>
                    <div class="code-block p-4 rounded mb-4">
                        <code class="text-sm text-gray-800">
                            DataStream&lt;String&gt; dataStream = env.fromElements(data);<br>
                            DataStream&lt;String&gt; uniqueStream = dataStream.distinct();
                        </code>
                    </div>
                    <p class="text-gray-600 text-sm">
                        <i class="fas fa-check-circle text-green-500 mr-1"></i>
                        支持实时数据处理；高效流式计算，适用于实时数据去重的场景
                    </p>
                </div>
            </div>
        </div>
    </section>

    <!-- Visualization Section -->
    <section id="visualization" class="py-16 px-4 md:px-0 bg-white">
        <div class="container mx-auto max-w-5xl">
            <div class="text-center mb-12">
                <h2 class="text-3xl font-bold text-gray-800 mb-4">数据去重方法关系图</h2>
                <p class="text-gray-600 max-w-2xl mx-auto">
                    通过可视化方式展示不同去重方法之间的关系和适用场景。
                </p>
            </div>
            
            <div class="mermaid">
                graph TD
                    A[数据去重方法] --> B[基于数据结构]
                    A --> C[基于数据库]
                    A --> D[基于算法]
                    A --> E[基于外部工具]
                    
                    B --> B1[集合(Set)]
                    B --> B2[Map]
                    B --> B3[Stream API]
                    B --> B4[排序去重]
                    B --> B5[位图去重]
                    
                    C --> C1[DISTINCT]
                    C --> C2[GROUP BY]
                    C --> C3[窗口函数]
                    C --> C4[MERGE INTO]
                    C --> C5[临时表]
                    
                    D --> D1[哈希表法]
                    D --> D2[排序法]
                    D --> D3[双指针法]
                    D --> D4[布隆过滤器]
                    
                    E --> E1[Apache Commons]
                    E --> E2[Google Guava]
                    E --> E3[Apache Spark]
                    E --> E4[Apache Flink]
                    
                    style A fill:#4a6cf7,color:white,stroke:#333
                    style B fill:#6e8efb,color:white,stroke:#333
                    style C fill:#6e8efb,color:white,stroke:#333
                    style D fill:#6e8efb,color:white,stroke:#333
                    style E fill:#6e8efb,color:white,stroke:#333
            </div>
            
            <div class="mt-12 grid md:grid-cols-2 gap-8">
                <div class="bg-blue-50 p-6 rounded-lg">
                    <h3 class="text-xl font-bold text-blue-800 mb-4">方法选择指南</h3>
                    <ul class="space-y-3">
                        <li class="flex items-start">
                            <i class="fas fa-check-circle text-blue-500 mr-2 mt-1"></i>
                            <span><strong>小规模数据：</strong>使用集合(Set)或哈希表法</span>
                        </li>
                        <li class="flex items-start">
                            <i class="fas fa-check-circle text-blue-500 mr-2 mt-1"></i>
                            <span><strong>数据库存储：</strong>优先使用SQL去重方法</span>
                        </li>
                        <li class="flex items-start">
                            <i class="fas fa-check-circle text-blue-500 mr-2 mt-1"></i>
                            <span><strong>大规模数据：</strong>考虑分布式工具如Spark/Flink</span>
                        </li>
                        <li class="flex items-start">
                            <i class="fas fa-check-circle text-blue-500 mr-2 mt-1"></i>
                            <span><strong>实时处理：</strong>选择流式处理框架</span>
                        </li>
                    </ul>
                </div>
                
                <div class="bg-green-50 p-6 rounded-lg">
                    <h3 class="text-xl font-bold text-green-800 mb-4">性能考虑因素</h3>
                    <ul class="space-y-3">
                        <li class="flex items-start">
                            <i class="fas fa-chart-line text-green-500 mr-2 mt-1"></i>
                            <span><strong>时间复杂度：</strong>从O(1)到O(n log n)不等</span>
                        </li>
                        <li class="flex items-start">
                            <i class="fas fa-memory text-green-500 mr-2 mt-1"></i>
                            <span><strong>空间复杂度：</strong>权衡内存使用和性能</span>
                        </li>
                        <li class="flex items-start">
                            <i class="fas fa-server text-green-500 mr-2 mt-1"></i>
                            <span><strong>分布式处理：</strong>大数据量时的扩展性</span>
                        </li>
                        <li class="flex items-start">
                            <i class="fas fa-bolt text-green-500 mr-2 mt-1"></i>
                            <span><strong>实时性要求：</strong>流处理vs批处理</span>
                        </li>
                    </ul>
                </div>
            </div>
        </div>
    </section>

    <!-- Conclusion Section -->
    <section class="py-16 px-4 md:px-0 bg-gray-900 text-white">
        <div class="container mx-auto max-w-5xl text-center">
            <h2 class="text-3xl font-bold mb-6">掌握数据去重，提升数据质量</h2>
            <p class="text-xl mb-8 max-w-2xl mx-auto opacity-90">
                选择合适的数据去重方法可以显著提高数据处理效率，降低存储成本，并确保分析结果的准确性。
            </p>
            <div class="flex flex-col sm:flex-row justify-center space-y-4 sm:space-y-0 sm:space-x-4">
                <a href="#" class="bg-white text-gray-900 px-6 py-3 rounded-full font-semibold hover:bg-gray-100 transition-all duration-300">
                    <i class="fas fa-book mr-2"></i>了解更多技术文章
                </a>
                <a href="#" class="border-2 border-white text-white px-6 py-3 rounded-full font-semibold hover:bg-white hover:text-gray-900 transition-all duration-300">
                    <i class="fas fa-envelope mr-2"></i>联系我们
                </a>
            </div>
        </div>
    </section>

    <!-- Footer -->
    <footer class="bg-gray-800 text-gray-300 py-8 px-4">
        <div class="container mx-auto max-w-5xl">
            <div class="flex flex-col md:flex-row justify-between items-center">
                <div class="mb-4 md:mb-0">
                    <h3 class="text-xl font-bold text-white mb-2">技术小馆</h3>
                    <p class="text-sm">分享前沿技术，提升开发技能</p>
                </div>
                <div>
                    <a href="http://www.yuque.com/jtostring" class="text-blue-400 hover:text-white transition-colors duration-300">
                        <i class="fas fa-globe mr-2"></i>http://www.yuque.com/jtostring
                    </a>
                </div>
            </div>
            <div class="mt-8 pt-6 border-t border-gray-700 text-center text-sm">
                <p>© 2024 技术小馆. 保留所有权利.</p>
            </div>
        </div>
    </footer>

    <script>
        // Initialize Mermaid
        mermaid.initialize({
            startOnLoad: true,
            theme: 'default',
            flowchart: {
                useMaxWidth: false,
                htmlLabels: true,
                curve: 'basis'
            }
        });
    </script>
</body>
</html>
```